package Bruce.GuavaDemo;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

import Bruce.GuavaDemo.company.Customer;
import com.google.common.base.Joiner;
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.*;
import org.junit.Test;

/**
 * https://www.cnblogs.com/Jack47/p/Guava-Collections.html map练习
 * https://www.cnblogs.com/Jack47/p/Guava-Common-Utilities.html 常用工具
 *
 * @author Bruce
 */
public class MapApiTest {
    /**
     * 集合声明 优点：简单
     */
    @Test
    public void collectionCreate() {
        Map<String, String> map = Maps.newHashMap();
        List<Map<String, String>> list = Lists.newArrayList();
        System.out.println(map);
        System.out.println(list);
    }

    /**
     * 集合初始化 优点：简单
     */
    @Test
    public void collectionInit() {
        Set<String> set = Sets.newHashSet("1", "2", "3");
        Map<String, String> map = ImmutableMap.of("kq", "v1", "k2", "v2");
        System.out.println(set);
        System.out.println(map);
    }

    /**
     * 不可变集合
     * 不可变性 优点：
     * 可以放心的给不信任的库使用 线程安全:
     * 可以被多个线程使用而不会有竞争条件发生
     * 不需要同步(synchronization)的逻辑，不需要支持互斥 设计和实现很简单。
     * 所有不可变的集合实现比可变版本的内存效率要高，分析见这里
     */
    @Test
    public void unmodifiable() {
//		方法一
        ImmutableSet<Integer> numbers = ImmutableSet.of(1, 2, 3);

//		方法二
        ImmutableSet<Integer> numbers2 = ImmutableSet.copyOf(numbers);

        System.out.println(numbers);
        System.out.println(numbers2);
    }

    /**
     * 新的集合类型
     * MultiMap 静态工厂方式创建
     * 可以用来替代 Map<k,Collection<v>>
     */
    @Test
    public void multiMapTest() {
        Multimap<String, Integer> multimap = HashMultimap.create();
        multimap.put("k1", 1);
        multimap.put("k1", 2);

        System.out.println(multimap);
        System.out.println(multimap.size());
        System.out.println(multimap.get("k1"));

        HashMultiset<Object> multiset = HashMultiset.create();
        multiset.add(1);
        multiset.add(2);
        multiset.add(3);
        multiset.add(1);
        System.out.println(multiset.contains(1));
        System.out.println(multiset.count(1));
        System.out.println( multiset.size());
        System.out.println( multiset);

    }
    @Test
    public void OptionalTest(){
        Integer var1 = 1;
        Integer var2 = null;
        Optional<Integer> possible1 = Optional.of(var1);//可以验证输入参数是否为空
        boolean isPresent1 = possible1.isPresent();
        System.out.println(isPresent1);
        Optional<Integer> possible2 = Optional.of(var2);//可以验证输入参数是否为空
        boolean isPresent2 = possible2.isPresent();
        System.out.println(isPresent2);
    }

    /**
     * 如果对象内部变量可以为null,实现equal函数有些费劲，因为需要单独检查null。
     * Objects.equal函数已经实现了对null敏感的检查，不会出现NullPointerException的异常。
     */
    @Test
    public void equestTest(){
        System.out.println(Objects.equal("a","a"));
        System.out.println(Objects.equal("a",null));
        System.out.println(Objects.equal(null,null));

        String var = null;
        System.out.println(var.equals(null));

    }

    /**
     *能处理 hashcode, ，它能够对指定顺序的多个字段进行哈希，这样就不用自己手工实现一遍对各个字段进行哈希的过程了
     */
    @Test
    public void hashcodeTest(){
        System.out.println(Objects.hashCode("我"));
        System.out.println(Objects.hashCode("我","和","你"));
    }

    /**
     *实现比较器(Comparator)，或者实现Comparable接口时，
     * 通常需要对类内部的所有成员变量进行比较，实现起来很麻烦。
     * Guava提供了ComparisonChain类，它能够进行"懒"比较：
     * 只有当发现为0的结果，才会继续后面的结果，不然就忽略后续的比较。举个例子
     * 返回 0 正确。 -1 不正确
     */
    @Test
    public void compareTest(){
        compareClass compareClass1 = new compareClass();
        compareClass1.setK1(1);
        compareClass1.setK2(2);
        compareClass compareClass2 = new compareClass();
        compareClass2.setK1(1);
        compareClass2.setK2(2);
        compareClass compareClass3 = new compareClass();
        compareClass3.setK1(1);
        compareClass3.setK2(3);

        System.out.println(
                ComparisonChain.start()
                        .compare(compareClass1.getK1(),compareClass2.getK1())
                        .compare(compareClass1.getK2(),compareClass2.getK2())
                        .result()
        );
        System.out.println(
                ComparisonChain.start()
                        .compare(compareClass1.getK1(),compareClass3.getK1())
                        .compare(compareClass1.getK2(),compareClass3.getK2())
                        .result()
        );
        System.out.println(
                ComparisonChain.start()
                        .compare(compareClass1.getK1(),compareClass2.getK1())
                        .result()
        );

    }

    class compareClass {
        private int k1;
        private int k2;

        public int getK1() {
            return k1;
        }

        public void setK1(int k1) {
            this.k1 = k1;
        }

        public int getK2() {
            return k2;
        }

        public void setK2(int k2) {
            this.k2 = k2;
        }
    }

    /**
     * 合并 joiner --流畅风格的Joiner提供了使用分隔符把一些字符串序列合并到一起的功能
     */
    @Test
    public  void StringTest(){
        Joiner joiner = Joiner.on(";").skipNulls();
//默认不接 null
        System.out.println( joiner.join("12",null,12,"23123"));
        System.out.println( "12"+null+12+"23123");


    }
}
